package model

import (
	"background/db"
	"background/utils"
	"reflect"

	"github.com/olivere/elastic/v7"
	"github.com/pkg/errors"
	"qiniupkg.com/x/log.v7"
)

const (
	ERR_COLUMN_EXISTED = "column_existed"
)

func HardwareTypeMapping() string {
	return `"mappings":{
		"hardware":{
            "properties":{
                "id":{"type":"keyword"},
				"name":{"type":"keyword"},
				"desc":{"type":"text"},
				"pic":{"type":"doc"},
				"doc":{"type":"doc"}
            }
	}
	}`
}

// this api is based on elasticsearch
type Hardware struct {
	ID      string `json:"_id,omitempty"`
	BuyDate string `json:"buy_date,omitempty"` //购入时间
	Name    string `json:"name,omitempty"`     // 名字
	Desc    string `json:"desc,omitempty"`     // 描述
	Pic     string `json:"pic,omitempty"`      // 图片
	Doc     string `json:"doc,omitempty"`      //文档资料
}

func (this *Hardware) CreateHardware() error {
	if nil == this {
		return errors.New(utils.ERRNULLPOINTER)
	}
	log.Print(this.Name)
	matchPhraseQuery := elastic.NewMatchQuery("name", this.Name)
	existedHardware, e := QueryHardwares(matchPhraseQuery, 10, 0)
	log.Print(e, existedHardware)

	for _, v := range existedHardware {
		if v.Name == this.Name {
			log.Print(v.ID)
			return errors.New(ERR_COLUMN_EXISTED)
		}
	}
	e = db.GetElastic().Create("hardware_data", "0", "", *this)
	if nil != e {
		log.Print("shit1")
		log.Print(e.Error())
		return e
	}
	log.Print("shit2")
	return nil
}

func GetHardwares(limit int, size int) ([]Hardware, error) {
	var ret []Hardware
	ids, e := db.GetElastic().Query("hardware_data", nil, reflect.TypeOf(Hardware{}), limit, size)
	if nil != e {
		return nil, e
	}
	i := 0
	for _, v := range ids {
		ret[i].ID = v
		i++
	}
	return ret, nil
}

func QueryHardwares(query elastic.Query, limit int, offset int) ([]Hardware, error) {
	ret := []Hardware{}
	ids, e := db.GetElastic().Query("hardware_data", query, ret, limit, offset)
	if nil != e {
		return nil, e
	}
	i := 0
	for _, v := range ids {
		ret[i].ID = v
		i++
	}
	return ret, nil
}

func QueryDoc(query elastic.Query, limit int, offset int) ([]DocTree, error) {
	ret := []DocTree{}
	_, e := db.GetElastic().Query("doc", query, &ret, limit, offset)
	if nil != e {
		return nil, e
	}
	return ret, nil
}
func QueryKnowledge(query elastic.Query, limit int, offset int) ([]DocTree, error) {
	ret := []DocTree{}
	_, e := db.GetElastic().Query("doc", query, &ret, limit, offset)
	if nil != e {
		return nil, e
	}
	return ret, nil
}

func DeleteHardware(name string) error {
	query := elastic.NewTermQuery("name", name)
	err := db.GetElastic().Delete(query, "hardware_data")
	if err != nil {
		return err
	}
	return nil
}
